package Servicios;

import DAO.SuperUsuarioDAO;
import Entidad.SuperUsuario;
import Singletons.Mensajes;
import Singletons.Restricciones;
import VO.SuperUsuarioVO;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import javax.persistence.EntityManager;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;

public class ServicioSuperusuario {

    public static String[] verArchivo() throws IOException {
        File archivo = null;
        FileReader fr = null;
        BufferedReader br = null;
        String[] datos = new String[6];
        try {
            archivo = new File("C:/WSBW/config.cfg");
            fr = new FileReader(archivo);
            br = new BufferedReader(fr);
            String linea;
            int i = 0;
            while ((linea = br.readLine()) != null) {
                datos[i]=linea;
                i++;
            }
            for(i=0; i < 6; i++){
                int j = 0;
                while(datos[i].charAt(j)!= ' ') j++;
                datos[i] = datos[i].substring(0, j);
            }
        } catch (IOException e) {
            File f = new File("C:/WSBW");
            if(!f.isDirectory())
                f.mkdir();
            datos[0] = "15";
            datos[1] = "2";
            datos[2] = "12";
            datos[3] = "3";
            datos[4] = "720";
            datos[5] = "24";
            FileWriter file = null;
            PrintWriter pw = null;
            file = new FileWriter("C:/WSBW/config.cfg");
            pw = new PrintWriter(file);
            pw.println("15     tamaño bloque");
            pw.println("2      # de bloques minimos por reserva");
            pw.println("12     # de bloques maximos por reserva");
            pw.println("3      # de fallas para penalizacion");
            pw.println("90    tiempo maximo anticipacion reserva de estacion");
            pw.println("1     tiempo minimo anticipacion reserva de sala");
            file.close();
        }
        return datos;
    }

    public static String validarRestricciones(int[] datos) {
        if(datos[0]<Restricciones.minTamañoBloque || datos[0]>Restricciones.maxTamañoBloque)
            return Mensajes.ERROR_TAMANO_BLOQUE;
        if(datos[1]<Restricciones.minMinimoBloquesRE || datos[1]>Restricciones.maxMinimoBloquesRE)
            return Mensajes.ERROR_BLOQUES_MINIMOS;
        if(datos[2]<Restricciones.minMaximoBloquesRE || datos[2]>Restricciones.maxMaximoBloquesRE)
            return Mensajes.ERROR_BLOQUES_MAXIMOS;
        if(datos[3]<Restricciones.minNumeroFallas || datos[3]>Restricciones.maxNumeroFallas)
            return Mensajes.ERROR_NUMERO_FALLAS;
        if(datos[4]<Restricciones.minTiempoMaximoRE || datos[4]>Restricciones.maxTiempoMaximoRE)
            return Mensajes.ERROR_TIEMPO_MAXIMO_RE;
        if(datos[5]<Restricciones.minTiempoMinimoRS || datos[5]>Restricciones.maxTiempoMinimoRS)
            return Mensajes.ERROR_TIEMPO_MINIMO_RS;
        return null;
    }

     /**
     * <p>Método que valida el inicio de sesión de un súper usuario.</p>
     *
     * @param cedula
     * @param contraseña
     *
     * @return Cédula del súper usuario si el login fue correcto, -3 si la
     * contraseña no coincide, -4 si el administrador no existe.
     */
    public boolean iniciarSesion (long cedula, char[] contraseña,EntityManager em){
        SuperUsuarioDAO dao = new SuperUsuarioDAO();
        SuperUsuario u = dao.encontrar(cedula,em);
        if (u!=null){
            if (Arrays.equals(contraseña, u.getContrasena())){
                return true;
            }else{
                return false;
            }
        }
        return false;
    }

    /**
     * <p>Busca y devuelve un superusuario cuya cedula sea la indicada</p>
     * @param cedula Long con el numero de cedula del superusuario que se desea encontrar
     * @param em EntityManager que se conecta con la base de datos
     * @return superusuarioVO con la informacion del superusuario encontrado o null si no se encontro
     */
    public SuperUsuarioVO getSuperusuario(long cedula,EntityManager em){
        SuperUsuarioDAO dao=new SuperUsuarioDAO();
        SuperUsuario superusuario=dao.encontrar(cedula, em);
        if(superusuario==null)
            return null;
        return superusuario_a_VO(superusuario);
    }

    /**
     * <p>Actualiza la informacion del superusuario pasado como argumento en la base de datos</p>
     * @param superusuarioVO SuperUsuarioVO que contiene toda la informacion del superusuario que se va a editar
     * @param em EntityManager que se conecta con la base de datos
     * @return true si la actualizacion fue exitosa, false de lo contrario
     */
    public void editarSuperusuario(SuperUsuarioVO superusuarioVO,EntityManager em){
        SuperUsuarioDAO dao=new SuperUsuarioDAO();
        dao.actualizar(VO_a_Superusuario(superusuarioVO),em);
    }

    /**
     * <p>Toma un superusuario y devuelve su version VO</p>
     * @param superusuario SuperUsuario
     * @return superusuarioVO con la misma informacion del argumento
     */
    private SuperUsuarioVO superusuario_a_VO(SuperUsuario superusuario){
        SuperUsuarioVO superusuarioVO=new SuperUsuarioVO();
        superusuarioVO.setCedula(superusuario.getCedula());
        superusuarioVO.setContrasena(superusuario.getContrasena());
        superusuarioVO.setNombre(superusuario.getNombre());
        return superusuarioVO;
    }

    /**
     * <p>Toma un superusuarioVO y devuelve su version superusuario</p>
     * @param superusuarioVO SuperUsuarioVO
     * @return superusuario con la misma informacion del argumento
     */
    private SuperUsuario VO_a_Superusuario(SuperUsuarioVO superusuarioVO){
        SuperUsuario superusuario=new SuperUsuario();
        superusuario.setCedula(superusuarioVO.getCedula());
        superusuario.setContrasena(superusuarioVO.getContrasena());
        superusuario.setNombre(superusuarioVO.getNombre());
        return superusuario;
    }

    public boolean actualizarArchivo(int[] datos) throws IOException {
        File archivo = new File("C:/WSBW/config.cfg");
        FileWriter fw = new FileWriter(archivo);
        PrintWriter pw = new PrintWriter(fw);
        pw.println(datos[0]+"   tamaño bloque");
        pw.println(datos[1]+"   # de bloques minimos por reserva");
        pw.println(datos[2]+"   # de bloques maximos por reserva");
        pw.println(datos[3]+"   # de fallas para penalizacion");
        pw.println(datos[4]+"   tiempo maximo anticipacion reserva de estacion");
        pw.println(datos[5]+"   tiempo minimo anticipacion reserva de sala");
        fw.close();
        return true;
    }

}